/*
* MATLAB Compiler: 4.13 (R2010a)
* Date: Sun Apr 08 22:30:32 2012
* Arguments: "-B" "macro_default" "-W" "dotnet:fromMatlab,fromMATLAB,3.5,private" "-T"
* "link:lib" "-d"
* "C:\Users\AbrahamV\Documents\Manipal\WS_project\NETconvert\fromMatlab\src" "-N" "-w"
* "enable:specified_file_mismatch" "-w" "enable:repeated_file" "-w"
* "enable:switch_ignored" "-w" "enable:missing_lib_sentinel" "-w" "enable:demo_license"
* "-v"
* "class{fromMATLAB:C:\Users\AbrahamV\Documents\Manipal\WS_project\NETconvert\ASSIGN_CLUST
* ER.m,C:\Users\AbrahamV\Documents\Manipal\WS_project\NETconvert\CLUSTER_MEAN.m,C:\Users\A
* brahamV\Documents\Manipal\WS_project\NETconvert\clusterplot.m,C:\Users\AbrahamV\Document
* s\Manipal\WS_project\NETconvert\drawgraph.m,C:\Users\AbrahamV\Documents\Manipal\WS_proje
* ct\NETconvert\drawgraph3.m,C:\Users\AbrahamV\Documents\Manipal\WS_project\NETconvert\NEA
* REST_DISTANCE.m,C:\Users\AbrahamV\Documents\Manipal\WS_project\NETconvert\trialcluster.m
* }" 
*/
using System;
using System.Reflection;
using System.IO;
using MathWorks.MATLAB.NET.Arrays;
using MathWorks.MATLAB.NET.Utility;
using MathWorks.MATLAB.NET.ComponentData;

#if SHARED
[assembly: System.Reflection.AssemblyKeyFile(@"")]
#endif

namespace fromMatlab
{
  /// <summary>
  /// The fromMATLAB class provides a CLS compliant, MWArray interface to the M-functions
  /// contained in the files:
  /// <newpara></newpara>
  /// C:\Users\AbrahamV\Documents\Manipal\WS_project\NETconvert\ASSIGN_CLUSTER.m
  /// <newpara></newpara>
  /// C:\Users\AbrahamV\Documents\Manipal\WS_project\NETconvert\CLUSTER_MEAN.m
  /// <newpara></newpara>
  /// C:\Users\AbrahamV\Documents\Manipal\WS_project\NETconvert\clusterplot.m
  /// <newpara></newpara>
  /// C:\Users\AbrahamV\Documents\Manipal\WS_project\NETconvert\drawgraph.m
  /// <newpara></newpara>
  /// C:\Users\AbrahamV\Documents\Manipal\WS_project\NETconvert\drawgraph3.m
  /// <newpara></newpara>
  /// C:\Users\AbrahamV\Documents\Manipal\WS_project\NETconvert\NEAREST_DISTANCE.m
  /// <newpara></newpara>
  /// C:\Users\AbrahamV\Documents\Manipal\WS_project\NETconvert\trialcluster.m
  /// <newpara></newpara>
  /// deployprint.m
  /// <newpara></newpara>
  /// printdlg.m
  /// </summary>
  /// <remarks>
  /// @Version 3.5
  /// </remarks>
  public class fromMATLAB : IDisposable
  {
    #region Constructors

    /// <summary internal= "true">
    /// The static constructor instantiates and initializes the MATLAB Compiler Runtime
    /// instance.
    /// </summary>
    static fromMATLAB()
    {
      if (MWMCR.MCRAppInitialized)
      {
        Assembly assembly= Assembly.GetExecutingAssembly();

        string ctfFilePath= assembly.Location;

        int lastDelimiter= ctfFilePath.LastIndexOf(@"\");

        ctfFilePath= ctfFilePath.Remove(lastDelimiter, (ctfFilePath.Length - lastDelimiter));

        string ctfFileName = MCRComponentState.MCC_fromMatlab_name_data + ".ctf";

        Stream embeddedCtfStream = null;

        String[] resourceStrings = assembly.GetManifestResourceNames();

        foreach (String name in resourceStrings)
        {
          if (name.Contains(ctfFileName))
          {
            embeddedCtfStream = assembly.GetManifestResourceStream(name);
            break;
          }
        }
        mcr= new MWMCR(MCRComponentState.MCC_fromMatlab_name_data,
                       MCRComponentState.MCC_fromMatlab_root_data,
                       MCRComponentState.MCC_fromMatlab_public_data,
                       MCRComponentState.MCC_fromMatlab_session_data,
                       MCRComponentState.MCC_fromMatlab_matlabpath_data,
                       MCRComponentState.MCC_fromMatlab_classpath_data,
                       MCRComponentState.MCC_fromMatlab_libpath_data,
                       MCRComponentState.MCC_fromMatlab_mcr_application_options,
                       MCRComponentState.MCC_fromMatlab_mcr_runtime_options,
                       MCRComponentState.MCC_fromMatlab_mcr_pref_dir,
                       MCRComponentState.MCC_fromMatlab_set_warning_state,
                       ctfFilePath, embeddedCtfStream, true);
      }
      else
      {
        throw new ApplicationException("MWArray assembly could not be initialized");
      }
    }


    /// <summary>
    /// Constructs a new instance of the fromMATLAB class.
    /// </summary>
    public fromMATLAB()
    {
    }


    #endregion Constructors

    #region Finalize

    /// <summary internal= "true">
    /// Class destructor called by the CLR garbage collector.
    /// </summary>
    ~fromMATLAB()
    {
      Dispose(false);
    }


    /// <summary>
    /// Frees the native resources associated with this object
    /// </summary>
    public void Dispose()
    {
      Dispose(true);

      GC.SuppressFinalize(this);
    }


    /// <summary internal= "true">
    /// Internal dispose function
    /// </summary>
    protected virtual void Dispose(bool disposing)
    {
      if (!disposed)
      {
        disposed= true;

        if (disposing)
        {
          // Free managed resources;
        }

        // Free native resources
      }
    }


    #endregion Finalize

    #region Methods

    /// <summary>
    /// Provides a single output, 0-input MWArrayinterface to the ASSIGN_CLUSTER
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// ASSIGN_CLUSTER Compute cluster position of points 
    /// ASSIGN_CLUSTER(dataset,cluster_num) will partition the 'dataset'
    /// according to K-means clustering algorithm. It will partition it into
    /// 'cluster_num' number of clusters. The function will return a single
    /// array showing the position of the differnt points in 'dataset'
    /// NOTE: It is assumed that the dataset has only 3 attributes per point
    /// </remarks>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray ASSIGN_CLUSTER()
    {
      return mcr.EvaluateFunction("ASSIGN_CLUSTER", new MWArray[]{});
    }


    /// <summary>
    /// Provides a single output, 1-input MWArrayinterface to the ASSIGN_CLUSTER
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// ASSIGN_CLUSTER Compute cluster position of points 
    /// ASSIGN_CLUSTER(dataset,cluster_num) will partition the 'dataset'
    /// according to K-means clustering algorithm. It will partition it into
    /// 'cluster_num' number of clusters. The function will return a single
    /// array showing the position of the differnt points in 'dataset'
    /// NOTE: It is assumed that the dataset has only 3 attributes per point
    /// </remarks>
    /// <param name="dataset">Input argument #1</param>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray ASSIGN_CLUSTER(MWArray dataset)
    {
      return mcr.EvaluateFunction("ASSIGN_CLUSTER", dataset);
    }


    /// <summary>
    /// Provides a single output, 2-input MWArrayinterface to the ASSIGN_CLUSTER
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// ASSIGN_CLUSTER Compute cluster position of points 
    /// ASSIGN_CLUSTER(dataset,cluster_num) will partition the 'dataset'
    /// according to K-means clustering algorithm. It will partition it into
    /// 'cluster_num' number of clusters. The function will return a single
    /// array showing the position of the differnt points in 'dataset'
    /// NOTE: It is assumed that the dataset has only 3 attributes per point
    /// </remarks>
    /// <param name="dataset">Input argument #1</param>
    /// <param name="cluster_num">Input argument #2</param>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray ASSIGN_CLUSTER(MWArray dataset, MWArray cluster_num)
    {
      return mcr.EvaluateFunction("ASSIGN_CLUSTER", dataset, cluster_num);
    }


    /// <summary>
    /// Provides the standard 0-input MWArray interface to the ASSIGN_CLUSTER M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// ASSIGN_CLUSTER Compute cluster position of points 
    /// ASSIGN_CLUSTER(dataset,cluster_num) will partition the 'dataset'
    /// according to K-means clustering algorithm. It will partition it into
    /// 'cluster_num' number of clusters. The function will return a single
    /// array showing the position of the differnt points in 'dataset'
    /// NOTE: It is assumed that the dataset has only 3 attributes per point
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] ASSIGN_CLUSTER(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "ASSIGN_CLUSTER", new MWArray[]{});
    }


    /// <summary>
    /// Provides the standard 1-input MWArray interface to the ASSIGN_CLUSTER M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// ASSIGN_CLUSTER Compute cluster position of points 
    /// ASSIGN_CLUSTER(dataset,cluster_num) will partition the 'dataset'
    /// according to K-means clustering algorithm. It will partition it into
    /// 'cluster_num' number of clusters. The function will return a single
    /// array showing the position of the differnt points in 'dataset'
    /// NOTE: It is assumed that the dataset has only 3 attributes per point
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="dataset">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] ASSIGN_CLUSTER(int numArgsOut, MWArray dataset)
    {
      return mcr.EvaluateFunction(numArgsOut, "ASSIGN_CLUSTER", dataset);
    }


    /// <summary>
    /// Provides the standard 2-input MWArray interface to the ASSIGN_CLUSTER M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// ASSIGN_CLUSTER Compute cluster position of points 
    /// ASSIGN_CLUSTER(dataset,cluster_num) will partition the 'dataset'
    /// according to K-means clustering algorithm. It will partition it into
    /// 'cluster_num' number of clusters. The function will return a single
    /// array showing the position of the differnt points in 'dataset'
    /// NOTE: It is assumed that the dataset has only 3 attributes per point
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="dataset">Input argument #1</param>
    /// <param name="cluster_num">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] ASSIGN_CLUSTER(int numArgsOut, MWArray dataset, MWArray cluster_num)
    {
      return mcr.EvaluateFunction(numArgsOut, "ASSIGN_CLUSTER", dataset, cluster_num);
    }


    /// <summary>
    /// Provides an interface for the ASSIGN_CLUSTER function in which the input and
    /// output
    /// arguments are specified as an array of MWArrays.
    /// </summary>
    /// <remarks>
    /// This method will allocate and return by reference the output argument
    /// array.<newpara></newpara>
    /// M-Documentation:
    /// ASSIGN_CLUSTER Compute cluster position of points 
    /// ASSIGN_CLUSTER(dataset,cluster_num) will partition the 'dataset'
    /// according to K-means clustering algorithm. It will partition it into
    /// 'cluster_num' number of clusters. The function will return a single
    /// array showing the position of the differnt points in 'dataset'
    /// NOTE: It is assumed that the dataset has only 3 attributes per point
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return</param>
    /// <param name= "argsOut">Array of MWArray output arguments</param>
    /// <param name= "argsIn">Array of MWArray input arguments</param>
    ///
    public void ASSIGN_CLUSTER(int numArgsOut, ref MWArray[] argsOut, MWArray[] argsIn)
    {
      mcr.EvaluateFunction("ASSIGN_CLUSTER", numArgsOut, ref argsOut, argsIn);
    }


    /// <summary>
    /// Provides a single output, 0-input MWArrayinterface to the CLUSTER_MEAN
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// CLUSTER_MEAN will return new center points 
    /// cluster_position is an array that contains the position of the clusters for
    /// datasets A,B &amp; C.
    /// </remarks>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray CLUSTER_MEAN()
    {
      return mcr.EvaluateFunction("CLUSTER_MEAN", new MWArray[]{});
    }


    /// <summary>
    /// Provides a single output, 1-input MWArrayinterface to the CLUSTER_MEAN
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// CLUSTER_MEAN will return new center points 
    /// cluster_position is an array that contains the position of the clusters for
    /// datasets A,B &amp; C.
    /// </remarks>
    /// <param name="cluster_position">Input argument #1</param>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray CLUSTER_MEAN(MWArray cluster_position)
    {
      return mcr.EvaluateFunction("CLUSTER_MEAN", cluster_position);
    }


    /// <summary>
    /// Provides a single output, 2-input MWArrayinterface to the CLUSTER_MEAN
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// CLUSTER_MEAN will return new center points 
    /// cluster_position is an array that contains the position of the clusters for
    /// datasets A,B &amp; C.
    /// </remarks>
    /// <param name="cluster_position">Input argument #1</param>
    /// <param name="A">Input argument #2</param>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray CLUSTER_MEAN(MWArray cluster_position, MWArray A)
    {
      return mcr.EvaluateFunction("CLUSTER_MEAN", cluster_position, A);
    }


    /// <summary>
    /// Provides a single output, 3-input MWArrayinterface to the CLUSTER_MEAN
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// CLUSTER_MEAN will return new center points 
    /// cluster_position is an array that contains the position of the clusters for
    /// datasets A,B &amp; C.
    /// </remarks>
    /// <param name="cluster_position">Input argument #1</param>
    /// <param name="A">Input argument #2</param>
    /// <param name="B">Input argument #3</param>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray CLUSTER_MEAN(MWArray cluster_position, MWArray A, MWArray B)
    {
      return mcr.EvaluateFunction("CLUSTER_MEAN", cluster_position, A, B);
    }


    /// <summary>
    /// Provides a single output, 4-input MWArrayinterface to the CLUSTER_MEAN
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// CLUSTER_MEAN will return new center points 
    /// cluster_position is an array that contains the position of the clusters for
    /// datasets A,B &amp; C.
    /// </remarks>
    /// <param name="cluster_position">Input argument #1</param>
    /// <param name="A">Input argument #2</param>
    /// <param name="B">Input argument #3</param>
    /// <param name="C">Input argument #4</param>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray CLUSTER_MEAN(MWArray cluster_position, MWArray A, MWArray B, MWArray C)
    {
      return mcr.EvaluateFunction("CLUSTER_MEAN", cluster_position, A, B, C);
    }


    /// <summary>
    /// Provides the standard 0-input MWArray interface to the CLUSTER_MEAN M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// CLUSTER_MEAN will return new center points 
    /// cluster_position is an array that contains the position of the clusters for
    /// datasets A,B &amp; C.
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] CLUSTER_MEAN(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "CLUSTER_MEAN", new MWArray[]{});
    }


    /// <summary>
    /// Provides the standard 1-input MWArray interface to the CLUSTER_MEAN M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// CLUSTER_MEAN will return new center points 
    /// cluster_position is an array that contains the position of the clusters for
    /// datasets A,B &amp; C.
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="cluster_position">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] CLUSTER_MEAN(int numArgsOut, MWArray cluster_position)
    {
      return mcr.EvaluateFunction(numArgsOut, "CLUSTER_MEAN", cluster_position);
    }


    /// <summary>
    /// Provides the standard 2-input MWArray interface to the CLUSTER_MEAN M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// CLUSTER_MEAN will return new center points 
    /// cluster_position is an array that contains the position of the clusters for
    /// datasets A,B &amp; C.
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="cluster_position">Input argument #1</param>
    /// <param name="A">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] CLUSTER_MEAN(int numArgsOut, MWArray cluster_position, MWArray A)
    {
      return mcr.EvaluateFunction(numArgsOut, "CLUSTER_MEAN", cluster_position, A);
    }


    /// <summary>
    /// Provides the standard 3-input MWArray interface to the CLUSTER_MEAN M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// CLUSTER_MEAN will return new center points 
    /// cluster_position is an array that contains the position of the clusters for
    /// datasets A,B &amp; C.
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="cluster_position">Input argument #1</param>
    /// <param name="A">Input argument #2</param>
    /// <param name="B">Input argument #3</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] CLUSTER_MEAN(int numArgsOut, MWArray cluster_position, MWArray A, 
                            MWArray B)
    {
      return mcr.EvaluateFunction(numArgsOut, "CLUSTER_MEAN", cluster_position, A, B);
    }


    /// <summary>
    /// Provides the standard 4-input MWArray interface to the CLUSTER_MEAN M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// CLUSTER_MEAN will return new center points 
    /// cluster_position is an array that contains the position of the clusters for
    /// datasets A,B &amp; C.
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="cluster_position">Input argument #1</param>
    /// <param name="A">Input argument #2</param>
    /// <param name="B">Input argument #3</param>
    /// <param name="C">Input argument #4</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] CLUSTER_MEAN(int numArgsOut, MWArray cluster_position, MWArray A, 
                            MWArray B, MWArray C)
    {
      return mcr.EvaluateFunction(numArgsOut, "CLUSTER_MEAN", cluster_position, A, B, C);
    }


    /// <summary>
    /// Provides an interface for the CLUSTER_MEAN function in which the input and output
    /// arguments are specified as an array of MWArrays.
    /// </summary>
    /// <remarks>
    /// This method will allocate and return by reference the output argument
    /// array.<newpara></newpara>
    /// M-Documentation:
    /// CLUSTER_MEAN will return new center points 
    /// cluster_position is an array that contains the position of the clusters for
    /// datasets A,B &amp; C.
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return</param>
    /// <param name= "argsOut">Array of MWArray output arguments</param>
    /// <param name= "argsIn">Array of MWArray input arguments</param>
    ///
    public void CLUSTER_MEAN(int numArgsOut, ref MWArray[] argsOut, MWArray[] argsIn)
    {
      mcr.EvaluateFunction("CLUSTER_MEAN", numArgsOut, ref argsOut, argsIn);
    }


    /// <summary>
    /// Provides a void output, 0-input MWArrayinterface to the clusterplot M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// This is to draw "num" scatter graphs with different colors for 
    /// all the clusters that are chosen
    /// </remarks>
    ///
    public void clusterplot()
    {
      mcr.EvaluateFunction(0, "clusterplot", new MWArray[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input MWArrayinterface to the clusterplot M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// This is to draw "num" scatter graphs with different colors for 
    /// all the clusters that are chosen
    /// </remarks>
    /// <param name="coords">Input argument #1</param>
    ///
    public void clusterplot(MWArray coords)
    {
      mcr.EvaluateFunction(0, "clusterplot", coords);
    }


    /// <summary>
    /// Provides a void output, 2-input MWArrayinterface to the clusterplot M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// This is to draw "num" scatter graphs with different colors for 
    /// all the clusters that are chosen
    /// </remarks>
    /// <param name="coords">Input argument #1</param>
    /// <param name="num">Input argument #2</param>
    ///
    public void clusterplot(MWArray coords, MWArray num)
    {
      mcr.EvaluateFunction(0, "clusterplot", coords, num);
    }


    /// <summary>
    /// Provides the standard 0-input MWArray interface to the clusterplot M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// This is to draw "num" scatter graphs with different colors for 
    /// all the clusters that are chosen
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] clusterplot(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "clusterplot", new MWArray[]{});
    }


    /// <summary>
    /// Provides the standard 1-input MWArray interface to the clusterplot M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// This is to draw "num" scatter graphs with different colors for 
    /// all the clusters that are chosen
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="coords">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] clusterplot(int numArgsOut, MWArray coords)
    {
      return mcr.EvaluateFunction(numArgsOut, "clusterplot", coords);
    }


    /// <summary>
    /// Provides the standard 2-input MWArray interface to the clusterplot M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// This is to draw "num" scatter graphs with different colors for 
    /// all the clusters that are chosen
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="coords">Input argument #1</param>
    /// <param name="num">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] clusterplot(int numArgsOut, MWArray coords, MWArray num)
    {
      return mcr.EvaluateFunction(numArgsOut, "clusterplot", coords, num);
    }


    /// <summary>
    /// Provides a void output, 0-input MWArrayinterface to the drawgraph M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// DRAWGRAPH Plot a curve from the specified x and y coordinates contained in the
    /// coords array.
    /// DRAWGRAPH (coords) Plots a curve from the specified coordinate values 
    /// in a MATLAB figure window.
    /// This file is used as an example for the MATLAB Builder NE product.
    /// </remarks>
    ///
    public void drawgraph()
    {
      mcr.EvaluateFunction(0, "drawgraph", new MWArray[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input MWArrayinterface to the drawgraph M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// DRAWGRAPH Plot a curve from the specified x and y coordinates contained in the
    /// coords array.
    /// DRAWGRAPH (coords) Plots a curve from the specified coordinate values 
    /// in a MATLAB figure window.
    /// This file is used as an example for the MATLAB Builder NE product.
    /// </remarks>
    /// <param name="coords">Input argument #1</param>
    ///
    public void drawgraph(MWArray coords)
    {
      mcr.EvaluateFunction(0, "drawgraph", coords);
    }


    /// <summary>
    /// Provides the standard 0-input MWArray interface to the drawgraph M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// DRAWGRAPH Plot a curve from the specified x and y coordinates contained in the
    /// coords array.
    /// DRAWGRAPH (coords) Plots a curve from the specified coordinate values 
    /// in a MATLAB figure window.
    /// This file is used as an example for the MATLAB Builder NE product.
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] drawgraph(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "drawgraph", new MWArray[]{});
    }


    /// <summary>
    /// Provides the standard 1-input MWArray interface to the drawgraph M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// DRAWGRAPH Plot a curve from the specified x and y coordinates contained in the
    /// coords array.
    /// DRAWGRAPH (coords) Plots a curve from the specified coordinate values 
    /// in a MATLAB figure window.
    /// This file is used as an example for the MATLAB Builder NE product.
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="coords">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] drawgraph(int numArgsOut, MWArray coords)
    {
      return mcr.EvaluateFunction(numArgsOut, "drawgraph", coords);
    }


    /// <summary>
    /// Provides a void output, 0-input MWArrayinterface to the drawgraph3 M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// DRAWGRAPH Plot a curve from the specified x and y coordinates contained in the
    /// coords array.
    /// DRAWGRAPH (coords) Plots a curve from the specified coordinate values 
    /// in a MATLAB figure window.
    /// This file is used as an example for the MATLAB Builder NE product.
    /// </remarks>
    ///
    public void drawgraph3()
    {
      mcr.EvaluateFunction(0, "drawgraph3", new MWArray[]{});
    }


    /// <summary>
    /// Provides a void output, 1-input MWArrayinterface to the drawgraph3 M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// DRAWGRAPH Plot a curve from the specified x and y coordinates contained in the
    /// coords array.
    /// DRAWGRAPH (coords) Plots a curve from the specified coordinate values 
    /// in a MATLAB figure window.
    /// This file is used as an example for the MATLAB Builder NE product.
    /// </remarks>
    /// <param name="coords">Input argument #1</param>
    ///
    public void drawgraph3(MWArray coords)
    {
      mcr.EvaluateFunction(0, "drawgraph3", coords);
    }


    /// <summary>
    /// Provides the standard 0-input MWArray interface to the drawgraph3 M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// DRAWGRAPH Plot a curve from the specified x and y coordinates contained in the
    /// coords array.
    /// DRAWGRAPH (coords) Plots a curve from the specified coordinate values 
    /// in a MATLAB figure window.
    /// This file is used as an example for the MATLAB Builder NE product.
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] drawgraph3(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "drawgraph3", new MWArray[]{});
    }


    /// <summary>
    /// Provides the standard 1-input MWArray interface to the drawgraph3 M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// DRAWGRAPH Plot a curve from the specified x and y coordinates contained in the
    /// coords array.
    /// DRAWGRAPH (coords) Plots a curve from the specified coordinate values 
    /// in a MATLAB figure window.
    /// This file is used as an example for the MATLAB Builder NE product.
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="coords">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] drawgraph3(int numArgsOut, MWArray coords)
    {
      return mcr.EvaluateFunction(numArgsOut, "drawgraph3", coords);
    }


    /// <summary>
    /// Provides a single output, 0-input MWArrayinterface to the NEAREST_DISTANCE
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// NEAREST_DISTANCE returns cluster position according to distance from
    /// center
    /// </remarks>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray NEAREST_DISTANCE()
    {
      return mcr.EvaluateFunction("NEAREST_DISTANCE", new MWArray[]{});
    }


    /// <summary>
    /// Provides a single output, 1-input MWArrayinterface to the NEAREST_DISTANCE
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// NEAREST_DISTANCE returns cluster position according to distance from
    /// center
    /// </remarks>
    /// <param name="A">Input argument #1</param>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray NEAREST_DISTANCE(MWArray A)
    {
      return mcr.EvaluateFunction("NEAREST_DISTANCE", A);
    }


    /// <summary>
    /// Provides a single output, 2-input MWArrayinterface to the NEAREST_DISTANCE
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// NEAREST_DISTANCE returns cluster position according to distance from
    /// center
    /// </remarks>
    /// <param name="A">Input argument #1</param>
    /// <param name="B">Input argument #2</param>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray NEAREST_DISTANCE(MWArray A, MWArray B)
    {
      return mcr.EvaluateFunction("NEAREST_DISTANCE", A, B);
    }


    /// <summary>
    /// Provides a single output, 3-input MWArrayinterface to the NEAREST_DISTANCE
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// NEAREST_DISTANCE returns cluster position according to distance from
    /// center
    /// </remarks>
    /// <param name="A">Input argument #1</param>
    /// <param name="B">Input argument #2</param>
    /// <param name="C">Input argument #3</param>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray NEAREST_DISTANCE(MWArray A, MWArray B, MWArray C)
    {
      return mcr.EvaluateFunction("NEAREST_DISTANCE", A, B, C);
    }


    /// <summary>
    /// Provides a single output, 4-input MWArrayinterface to the NEAREST_DISTANCE
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// NEAREST_DISTANCE returns cluster position according to distance from
    /// center
    /// </remarks>
    /// <param name="A">Input argument #1</param>
    /// <param name="B">Input argument #2</param>
    /// <param name="C">Input argument #3</param>
    /// <param name="A_center">Input argument #4</param>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray NEAREST_DISTANCE(MWArray A, MWArray B, MWArray C, MWArray A_center)
    {
      return mcr.EvaluateFunction("NEAREST_DISTANCE", A, B, C, A_center);
    }


    /// <summary>
    /// Provides a single output, 5-input MWArrayinterface to the NEAREST_DISTANCE
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// NEAREST_DISTANCE returns cluster position according to distance from
    /// center
    /// </remarks>
    /// <param name="A">Input argument #1</param>
    /// <param name="B">Input argument #2</param>
    /// <param name="C">Input argument #3</param>
    /// <param name="A_center">Input argument #4</param>
    /// <param name="B_center">Input argument #5</param>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray NEAREST_DISTANCE(MWArray A, MWArray B, MWArray C, MWArray A_center, 
                              MWArray B_center)
    {
      return mcr.EvaluateFunction("NEAREST_DISTANCE", A, B, C, A_center, B_center);
    }


    /// <summary>
    /// Provides a single output, 6-input MWArrayinterface to the NEAREST_DISTANCE
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// NEAREST_DISTANCE returns cluster position according to distance from
    /// center
    /// </remarks>
    /// <param name="A">Input argument #1</param>
    /// <param name="B">Input argument #2</param>
    /// <param name="C">Input argument #3</param>
    /// <param name="A_center">Input argument #4</param>
    /// <param name="B_center">Input argument #5</param>
    /// <param name="C_center">Input argument #6</param>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray NEAREST_DISTANCE(MWArray A, MWArray B, MWArray C, MWArray A_center, 
                              MWArray B_center, MWArray C_center)
    {
      return mcr.EvaluateFunction("NEAREST_DISTANCE", A, B, C, A_center, B_center, C_center);
    }


    /// <summary>
    /// Provides the standard 0-input MWArray interface to the NEAREST_DISTANCE
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// NEAREST_DISTANCE returns cluster position according to distance from
    /// center
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] NEAREST_DISTANCE(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "NEAREST_DISTANCE", new MWArray[]{});
    }


    /// <summary>
    /// Provides the standard 1-input MWArray interface to the NEAREST_DISTANCE
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// NEAREST_DISTANCE returns cluster position according to distance from
    /// center
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="A">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] NEAREST_DISTANCE(int numArgsOut, MWArray A)
    {
      return mcr.EvaluateFunction(numArgsOut, "NEAREST_DISTANCE", A);
    }


    /// <summary>
    /// Provides the standard 2-input MWArray interface to the NEAREST_DISTANCE
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// NEAREST_DISTANCE returns cluster position according to distance from
    /// center
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="A">Input argument #1</param>
    /// <param name="B">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] NEAREST_DISTANCE(int numArgsOut, MWArray A, MWArray B)
    {
      return mcr.EvaluateFunction(numArgsOut, "NEAREST_DISTANCE", A, B);
    }


    /// <summary>
    /// Provides the standard 3-input MWArray interface to the NEAREST_DISTANCE
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// NEAREST_DISTANCE returns cluster position according to distance from
    /// center
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="A">Input argument #1</param>
    /// <param name="B">Input argument #2</param>
    /// <param name="C">Input argument #3</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] NEAREST_DISTANCE(int numArgsOut, MWArray A, MWArray B, MWArray C)
    {
      return mcr.EvaluateFunction(numArgsOut, "NEAREST_DISTANCE", A, B, C);
    }


    /// <summary>
    /// Provides the standard 4-input MWArray interface to the NEAREST_DISTANCE
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// NEAREST_DISTANCE returns cluster position according to distance from
    /// center
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="A">Input argument #1</param>
    /// <param name="B">Input argument #2</param>
    /// <param name="C">Input argument #3</param>
    /// <param name="A_center">Input argument #4</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] NEAREST_DISTANCE(int numArgsOut, MWArray A, MWArray B, MWArray C, 
                                MWArray A_center)
    {
      return mcr.EvaluateFunction(numArgsOut, "NEAREST_DISTANCE", A, B, C, A_center);
    }


    /// <summary>
    /// Provides the standard 5-input MWArray interface to the NEAREST_DISTANCE
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// NEAREST_DISTANCE returns cluster position according to distance from
    /// center
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="A">Input argument #1</param>
    /// <param name="B">Input argument #2</param>
    /// <param name="C">Input argument #3</param>
    /// <param name="A_center">Input argument #4</param>
    /// <param name="B_center">Input argument #5</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] NEAREST_DISTANCE(int numArgsOut, MWArray A, MWArray B, MWArray C, 
                                MWArray A_center, MWArray B_center)
    {
      return mcr.EvaluateFunction(numArgsOut, "NEAREST_DISTANCE", A, B, C, A_center, B_center);
    }


    /// <summary>
    /// Provides the standard 6-input MWArray interface to the NEAREST_DISTANCE
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// NEAREST_DISTANCE returns cluster position according to distance from
    /// center
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="A">Input argument #1</param>
    /// <param name="B">Input argument #2</param>
    /// <param name="C">Input argument #3</param>
    /// <param name="A_center">Input argument #4</param>
    /// <param name="B_center">Input argument #5</param>
    /// <param name="C_center">Input argument #6</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] NEAREST_DISTANCE(int numArgsOut, MWArray A, MWArray B, MWArray C, 
                                MWArray A_center, MWArray B_center, MWArray C_center)
    {
      return mcr.EvaluateFunction(numArgsOut, "NEAREST_DISTANCE", A, B, C, A_center, B_center, C_center);
    }


    /// <summary>
    /// Provides an interface for the NEAREST_DISTANCE function in which the input and
    /// output
    /// arguments are specified as an array of MWArrays.
    /// </summary>
    /// <remarks>
    /// This method will allocate and return by reference the output argument
    /// array.<newpara></newpara>
    /// M-Documentation:
    /// NEAREST_DISTANCE returns cluster position according to distance from
    /// center
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return</param>
    /// <param name= "argsOut">Array of MWArray output arguments</param>
    /// <param name= "argsIn">Array of MWArray input arguments</param>
    ///
    public void NEAREST_DISTANCE(int numArgsOut, ref MWArray[] argsOut, MWArray[] argsIn)
    {
      mcr.EvaluateFunction("NEAREST_DISTANCE", numArgsOut, ref argsOut, argsIn);
    }


    /// <summary>
    /// Provides a single output, 0-input MWArrayinterface to the trialcluster
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// A "trial" of the clustering algorithm. Basically this is how a skeleton of the 
    /// final function will look like.
    /// coords is a 3D array with the elements that need to be clustered. In our case
    /// it's the different data from the XML files.
    /// num is the number of clusters that need to be calculated.
    /// result will be a 1-D array that simply shows the cluster each element in coords
    /// belongs
    /// to after the clustering is complete.
    /// We'll count cluster numbers from 1.
    /// </remarks>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray trialcluster()
    {
      return mcr.EvaluateFunction("trialcluster", new MWArray[]{});
    }


    /// <summary>
    /// Provides a single output, 1-input MWArrayinterface to the trialcluster
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// A "trial" of the clustering algorithm. Basically this is how a skeleton of the 
    /// final function will look like.
    /// coords is a 3D array with the elements that need to be clustered. In our case
    /// it's the different data from the XML files.
    /// num is the number of clusters that need to be calculated.
    /// result will be a 1-D array that simply shows the cluster each element in coords
    /// belongs
    /// to after the clustering is complete.
    /// We'll count cluster numbers from 1.
    /// </remarks>
    /// <param name="coords">Input argument #1</param>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray trialcluster(MWArray coords)
    {
      return mcr.EvaluateFunction("trialcluster", coords);
    }


    /// <summary>
    /// Provides a single output, 2-input MWArrayinterface to the trialcluster
    /// M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// A "trial" of the clustering algorithm. Basically this is how a skeleton of the 
    /// final function will look like.
    /// coords is a 3D array with the elements that need to be clustered. In our case
    /// it's the different data from the XML files.
    /// num is the number of clusters that need to be calculated.
    /// result will be a 1-D array that simply shows the cluster each element in coords
    /// belongs
    /// to after the clustering is complete.
    /// We'll count cluster numbers from 1.
    /// </remarks>
    /// <param name="coords">Input argument #1</param>
    /// <param name="num">Input argument #2</param>
    /// <returns>An MWArray containing the first output argument.</returns>
    ///
    public MWArray trialcluster(MWArray coords, MWArray num)
    {
      return mcr.EvaluateFunction("trialcluster", coords, num);
    }


    /// <summary>
    /// Provides the standard 0-input MWArray interface to the trialcluster M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// A "trial" of the clustering algorithm. Basically this is how a skeleton of the 
    /// final function will look like.
    /// coords is a 3D array with the elements that need to be clustered. In our case
    /// it's the different data from the XML files.
    /// num is the number of clusters that need to be calculated.
    /// result will be a 1-D array that simply shows the cluster each element in coords
    /// belongs
    /// to after the clustering is complete.
    /// We'll count cluster numbers from 1.
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] trialcluster(int numArgsOut)
    {
      return mcr.EvaluateFunction(numArgsOut, "trialcluster", new MWArray[]{});
    }


    /// <summary>
    /// Provides the standard 1-input MWArray interface to the trialcluster M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// A "trial" of the clustering algorithm. Basically this is how a skeleton of the 
    /// final function will look like.
    /// coords is a 3D array with the elements that need to be clustered. In our case
    /// it's the different data from the XML files.
    /// num is the number of clusters that need to be calculated.
    /// result will be a 1-D array that simply shows the cluster each element in coords
    /// belongs
    /// to after the clustering is complete.
    /// We'll count cluster numbers from 1.
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="coords">Input argument #1</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] trialcluster(int numArgsOut, MWArray coords)
    {
      return mcr.EvaluateFunction(numArgsOut, "trialcluster", coords);
    }


    /// <summary>
    /// Provides the standard 2-input MWArray interface to the trialcluster M-function.
    /// </summary>
    /// <remarks>
    /// M-Documentation:
    /// A "trial" of the clustering algorithm. Basically this is how a skeleton of the 
    /// final function will look like.
    /// coords is a 3D array with the elements that need to be clustered. In our case
    /// it's the different data from the XML files.
    /// num is the number of clusters that need to be calculated.
    /// result will be a 1-D array that simply shows the cluster each element in coords
    /// belongs
    /// to after the clustering is complete.
    /// We'll count cluster numbers from 1.
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return.</param>
    /// <param name="coords">Input argument #1</param>
    /// <param name="num">Input argument #2</param>
    /// <returns>An Array of length "numArgsOut" containing the output
    /// arguments.</returns>
    ///
    public MWArray[] trialcluster(int numArgsOut, MWArray coords, MWArray num)
    {
      return mcr.EvaluateFunction(numArgsOut, "trialcluster", coords, num);
    }


    /// <summary>
    /// Provides an interface for the trialcluster function in which the input and output
    /// arguments are specified as an array of MWArrays.
    /// </summary>
    /// <remarks>
    /// This method will allocate and return by reference the output argument
    /// array.<newpara></newpara>
    /// M-Documentation:
    /// A "trial" of the clustering algorithm. Basically this is how a skeleton of the 
    /// final function will look like.
    /// coords is a 3D array with the elements that need to be clustered. In our case
    /// it's the different data from the XML files.
    /// num is the number of clusters that need to be calculated.
    /// result will be a 1-D array that simply shows the cluster each element in coords
    /// belongs
    /// to after the clustering is complete.
    /// We'll count cluster numbers from 1.
    /// </remarks>
    /// <param name="numArgsOut">The number of output arguments to return</param>
    /// <param name= "argsOut">Array of MWArray output arguments</param>
    /// <param name= "argsIn">Array of MWArray input arguments</param>
    ///
    public void trialcluster(int numArgsOut, ref MWArray[] argsOut, MWArray[] argsIn)
    {
      mcr.EvaluateFunction("trialcluster", numArgsOut, ref argsOut, argsIn);
    }


    /// <summary>
    /// This method will cause a MATLAB figure window to behave as a modal dialog box.
    /// The method will not return until all the figure windows associated with this
    /// component have been closed.
    /// </summary>
    /// <remarks>
    /// An application should only call this method when required to keep the
    /// MATLAB figure window from disappearing.  Other techniques, such as calling
    /// Console.ReadLine() from the application should be considered where
    /// possible.</remarks>
    ///
    public void WaitForFiguresToDie()
    {
      mcr.WaitForFiguresToDie();
    }



    #endregion Methods

    #region Class Members

    private static MWMCR mcr= null;

    private bool disposed= false;

    #endregion Class Members
  }
}
